stazsoftware.com/www.stazsoftware.com.tar/www.stazsoftware.com/futurebasic/sample-code/DBFD.sit/DBFD2.0/DataBrowser With Toolbox/BasicDataBrowser 1.1.bas

BASIC Source File | 2005-01-16 | 80KB | 2,292 lines

'~'A
'                       Runtime : Rntm Appearance.Incl
'                           CPU : Carbon
'                    CALL Req'd : Off
'~'B
/*
     DataBrowser demo (experimental). Version 1.0 beta

     Freely adaptated from the original C code by Apple, this little demo
     is intended to illustrate the strength of the DataBrowser Carbon control
     that sports impressive features.

          Ñ No limitation on the number of cells displayed in a list,
          Ñ Built-in drag-and-drop handling,
          Ñ Built-in display types for text, icons, checkboxes, pop-up menus,
            progress bars, relevance ranks, and sliders,
          Ñ Support for contextual menus and context-sensitive help,
          Ñ Built-in text editing for cells displaying text, and
          Ñ Built-in hierarchical list support.

CREATING A DATABROWER
'~'9
     A DataBrowser is really a control that you create and install in a window,
     however there is a specific Toolbox function for that purpose, namely
     CreateDataBrowserControl.

INSTALLING CALLBACK PROCEDURES
'~'9
     This particular control communicates with your application via a set of
     callback procedures that you must install calling InitDataBrowserCallbacks
     after you have filled the appropriate fields of a particular structure.

     Only one of these procedures is required: itemDataCallback which is called
     when the DataBrowser asks your program for the actual data it must display.
     The other optional callback procedures deal with the Drag & Drop,
     Carbon Help tags and Contextual menu features. There are also two additional
     callback procedures, one is itemNotificationCallback which is called
     when interesting conditions happen during the interaction of the end user
     with the DataBrowser, the other, itemCompareCallback, lets you define a
     specific method for sorting items that the DataBrowser can't handle automatically.

     If you need more customization you can install extra callback procedures
     with InitDataBrowserCustomCallbacks (passing to it another specific structure
     whose fields include drawItemCallback, editTextCallback, hitTestCallback, etc.)
     Read the Apple documentation for more info.

CONFIGURING THE DATABROWSER (adding columns)
'~'9
     Once you have installed your callback routines, you must configure
     the DataBrowser. Basically, it consists in defining each column. This is done
     with, again, a structure called DataBrowserListViewColumnDesc that describes
     various properties shared by the items in that column. The stucture has two
     fields (propertyDesc and headerBtnDesc) that are also records. All the fields
     of the whole record must be explicitely set. Here is the complete set:

          DIM columnDescriptor AS DataBrowserListViewColumnDesc

          columnDescriptor.propertyDesc.DataBrowserPropertyID
          columnDescriptor.propertyDesc.DataBrowserPropertyType
          columnDescriptor.propertyDesc.DataBrowserPropertyFlags

          columnDescriptor.headerBtnDesc.version
          columnDescriptor.headerBtnDesc.minimumWidth
          columnDescriptor.headerBtnDesc.maximumWidth
          columnDescriptor.headerBtnDesc.titleOffset
          columnDescriptor.headerBtnDesc.titleString
          columnDescriptor.headerBtnDesc.initialOrder
          columnDescriptor.headerBtnDesc.btnFontStyle   (<=== ControlFontStyleRec )
          columnDescriptor.headerBtnDesc.btnContentInfo (<=== ControlButtonContentInfo )

     Note that the DataBrowserPropertyID is a number that identifies the column; you
     can think of it as a button ID. You may simply define a constant that would ease
     the reading of your code later, for example:

     _columnName = _"name"
     _columnTel  = _"phon"
     and so on...

     Then you can add the column in the DataBrowser with AddDataBrowserListViewColumn
     and repeat the operation for the next column. And that's it. Well almost...

ADDING ITEMS TO THE LIST (adding rows)
'~'9
     You must supply then the data to display. Here in the demo, we have a notification
     callback procedure that will be invoked when the DataBrowser is opened,
     so we will take that opportunity to fill in the browser with data. You must keep
     in mind that the data you provide at this time are not the actual data that your
     program maintains but they are numbers, each one uniquely identifying an item.
     The DataBrowser maintains that list of identifiers and will ask your program later
     to provide the information it must display for each item (i.e. when the itemDataCallback
     procedure is called.)

     Adding identifiers is like adding rows in a table and it is done with:

     AddDataBrowserItems( browser, container, numItems, itemsPtr, preSort )

     browser   is the DataBrowser ControlRef
     container may be set to an existing itemID, in this case, the items added are
               subItems and the list is a hierarchical list.
     numItems  is the number of items you want to add at once
     itemsPtr  is a pointer to the identifiers you want to add (it can be the address
               of an array of identifiers).
     preSort   tells the DataBrowser if the new items are already sorted or not.

DISPLAYING THE INFO
'~'9
     Now that you have columns and rows, you can display each cell in the table.
     When the DataBrowser control needs to update the display, it calls your
     application via the itemDataCallback routine. It is to note that the same routine
     is invoked both for getting and setting the data of the cells. The DataBrowser
     can inform your program when the end user has changed a cell's content. If you
     accept the change, your program must synchronize internally its own data so that
     the next time the DataBrowser calls the routine to update the display the right
     information is passed back. This is not shown in the current demo that merely
     provides info to the DataBrowser for the display only.

     The itemDataCallback procedure (also known as GetSetItemDataProc) receives
     the following parameters:

     GetSetItemDataProc( browser , itemID, propertyID, itemData, changeValue)

     browser     is the DataBrowser ControlRef
     itemID      is the item identifier (the row in the table)
     property    is the column identifier
     itemData    is a pointer to a buffer that contains or will receive the data
     changeValue is a boolean value. If that parameter is true, that means that
                 the cell's content has been changed by the end user, and you
                 can retrieve the new value in the itemData buffer. You must then
                 update the info that your program maintains internally. If changeValue
                 is false, you are asked to pass the value in the itemData buffer
                 so that the DataBrowser can display the correct information to the
                 end user.

     The value stored or retrieved via the itemData buffer depends on the column's type.
     Note that each type has its own Toolbox getter and setter functions, for example:
     SetDataBrowserItemDataText, GetDataBrowserItemDataIcon, SetDataBrowserItemDataBooleanValue

     In this demo there are two dialog windows that allow you to change some other settings of
     the DataBrowser. Toying a bit with the program, you will be impressed by that
     incredible control (try to drag the column headers, or to play with the keyboard for instance)

 ADDITIONAL NOTE
'~'9
     This is the basis to start, but there's much more to learn about this versatile control.
     You should read Apple Technote 2009 for more in depth information.

     The DataBrowser is somewhat intimidating at first glance, but once you have understood
     the principles, all becomes easier. The demo wants to showcase the main features,
     but there is much more to learn and discover on that powerful control.

     The known bugs:

     Ñ the column checkbox behaves strangely

     Ñ the application crash on closing the main window via the Close menu item
     has been fixed thanks to Robert Purves.

     I have also improved a bit the original demo from Apple, but I have also
     cluttered slightly the code because I wanted to use prototype functions
     with all the callback procedures defined in this program.

                                                                 Alain   April 2003
*/
'~'6

resources "Basic DataBrower.rsrc"

include "Tlbx DragMgr.Incl"// used for declarations for drag&drop support
include "Tlbx MacHelp.Incl"// used for help tags support ?
include "Tlbx CarbonEvents.Incl"// original FB header for Carbon Events

include "Tlbx ControlDefinitions.Incl"// my converted Apple header file for data browser declaration

'~Toolbox Added Declarations

#define DialogItemIndex       as SInt16
#define ClickActivationResult as UInt32

begin record hlRec
dim lHigh as UInt32
dim lLow  as UInt32
end record

begin record LongDateCvt
begin union
dim c.64 'as  SInt64
dim hl as hlRec
end union
end record

_kWindowInWindowMenuAttribute  = (1 << 27 )
_kControlDataBrowserPart       = 24
_typeUInt32 = _"magn"
_kControlNoContent = 0
_normal = 0

_kControlFontViewSystemFont    = -4 /* force to views system font (DataBrowser control only)*/

toolbox fn SetAutomaticControlDragTrackingEnabledForWindow( WindowRef inWindow, Boolean inTracks) = OSStatus
toolbox fn GetDialogWindow(DialogRef dialog) = WindowRef
toolbox fn SetControlProperty ( ControlRef c, OSType propertyCreator, OSType propertyTag, UInt32 propertySize, ptr * propertyData ) = OSStatus
toolbox fn GetControlProperty ( ControlRef c, OSType propertyCreator, OSType propertyTag, UInt32 bufferSize, UInt32 * actualSize, ptr * propertyBuffer ) = OSStatus
toolbox fn GetControlPropertySize ( ControlRef c, OSType propertyCreator, OSType propertyTag, UInt32 * size ) = OSStatus
toolbox fn RemoveControlProperty ( ControlRef c, OSType propertyCreator, OSType propertyTag ) = OSStatus
toolbox fn SetWindowClass(WindowRef,WindowClass) = OSStatus
toolbox fn GetDialogFromWindow(WindowRef window) = DialogRef
toolbox fn CFAllocatorGetDefault = CFAllocatorRef
toolbox fn GetControlClickActivation( ControlRef inControl, Point inWhere, EventModifiers inModifiers, ClickActivationResult * outResult) = OSStatus
toolbox fn CompareString( str255 aStr, str255 bStr, Handle itl2Handle) = short

'~Application Constants

begin enum
_folderIndex
_documentIndex
_folderAliasIndex

_totalNumIcons

_settingsDLOGResID   = 130
_customizeDLOGResID  = 129

_contextualMenuResID = 200
end enum

begin enum 2
_noDisjointBtn
_dragSelectBtn
_alwaysExtendBtn
_selectOnlyOneBtn
_resetSelectionBtn
_commandTogglesBtn

_activeItemsBtn
_frameAndFocusBtn
_verticalScrollBtn
_horizontalScrollBtn

_noEmptySelectionBtn
end enum

begin enum 1
_disclosureBtn
_varHeightRowsBtn
_expandableRowsBtn

_plainBackgroundBtn
_fillHiliteStyleBtn
_useRelativesDatesBtn
_showHeaderButtonsBtn
end enum

begin enum
_closeWindowCmd         = _"clos"

_DataBrowserSettingsCmd = _"stng"
_customizeViewCmd       = _"cust"
_showPlacardCmd         = _"plac"

_showFrameCmd           = _"fram"
_revealItemCmd          = _"show"
_selectionFlagsCmd      = _"flag"
end enum

begin enum
_itemsPerContainer  = 10

_myCreator          = _"DEMO"
_myDataBrowser      = _"Brsr"
_myEventHandler     = _"Evnt"
_myCustomizerID     = _" ID "

_checkboxColumnID   = _"cbox"
_flavorColumnID     = _"flvr"
_colorColumnID      = _"colr"
_indexColumnID      = _"indx"
_itemIDColumnID     = _"item"
_iconOnlyColumnID   = _"icon"
_dateTimeColumnID   = _"date"
_popupMenuColumnID  = _"menu"
_progressColumnID   = _"pbar"
_sliderColumnID     = _"sldr"
end enum

begin enum
_btnHeight      = 20
_btnWidth       = 60
_scrollBarWidth = 16
end enum

'~Application Globals

begin globals

dim &&
dim as MenuRef                      gContextualMenu
dim as ControlRef                   gPlacard
dim as IconRef                      gIcon(_totalNumIcons)
dim as DataBrowserTableViewColumnID gCols(9)

dim as proc                         gPlacardDrawProc

dim as proc                         gAcceptDragProc
dim as proc                         gReceiveDragProc
dim as proc                         gAddDragItemProc
dim as proc                         gGetSetItemDataProc
dim as proc                         gItemComparisonProc
dim as proc                         gItemNotificationProc
dim as proc                         gItemHelpContentProc
dim as proc                         gGetContextualMenuProc
dim as proc                         gSelectContextualMenuProc

dim as proc                         gDialogEventHandlerProc
dim as proc                         gWindowEventHandlerProc

end globals

'~------
'~Prototype Functions
/*
     I have changed the original coding using here protoype functions
     that the callback procedures will use.
     The local functions that will be actually called by the procedures are
     set in SetupMyVectors fn.
*/
def fn Proto_PlacardDraw( c as ControlRef, dummy as SInt16 ) using gPlacardDrawProc

def fn Proto_AcceptDrag( browser as ControlRef, theDrag as DragReference, itemID as DataBrowserItemID ) using gAcceptDragProc
def fn Proto_ReceiveDrag( browser as ControlRef, theDrag as DragReference, itemID as DataBrowserItemID ) using gReceiveDragProc
def fn Proto_AddDragItem( browser as ControlRef, theDrag as DragReference, inItemID as DataBrowserItemID, itemRef as .ItemReference ) using gAddDragItemProc
def fn Proto_GetSetItemData( browser as ControlRef, itemID as DataBrowserItemID, prop as DataBrowserPropertyID, itemData as DataBrowserItemDataRef, changeValue as Boolean ) using gGetSetItemDataProc
def fn Proto_ItemComparison( browser as ControlRef, itemOneID as DataBrowserItemID, itemTwoID as DataBrowserItemID, sortProperty as DataBrowserPropertyID ) using gItemComparisonProc
def fn Proto_ItemNotification( browser as ControlRef, itemID as DataBrowserItemID, message as DataBrowserItemNotification ) using gItemNotificationProc
def fn Proto_ItemHelpContent(browser as ControlRef,item as DataBrowserItemID,prop as DataBrowserPropertyID,inRequest as HMContentRequest,outContentProvided as .HMContentProvidedType, ioHelpContent as .HMHelpContentRec ) using gItemHelpContentProc
def fn Proto_ContextualMenu( browser as ControlRef, contextualMenu as .MenuRef, helpType as .UInt32, helpItemString as .CFStringRef, selection as .AEDesc ) using gGetContextualMenuProc
def fn Proto_SelectContextualMenu( browser as ControlRef, contextualMenu as MenuRef, selectionType as UInt32, menuID as SInt16, menuItem as MenuItemIndex  ) using gSelectContextualMenuProc

def fn Proto_DialogEventHandler( EventHandlerCallRef as ptr, inEvent as EventRef, void as ptr ) using gDialogEventHandlerProc
def fn Proto_WindowEventHandler( EventHandlerCallRef as ptr, inEvent as EventRef, void as ptr ) using gWindowEventHandlerProc

'~';
'~-
'~Utility Functions

def fn InstallWindowEventHandler( t, h, n, @l, @u, @r ) = fn InstallEventHandler( fn GetWindowEventTarget( t ), h, n, #l, #u, #r )
def fn SendEventToWindow( e, t ) = fn SendEventToEventTarget( e, fn GetWindowEventTarget( t ) )

/*
     This is a dummy function, never called by the program, just
     here to store string lists (easier to edit in the source code)
*/
local Fn CreateStrLists

dim as str255 s

begin enum 128
_flavorListResID
_colorListResID
_commentListResID
end enum

stringlist on
stringlist  = _flavorListResID,"Flavors"
s = "Lime"
s = "Tangerine"
s = "Strawberry"
s = "Grape"
s = "Blueberry"
stringlist end

stringlist = _colorListResID  ,"Colors"
s = "Green"
s = "Orange"
s = "Red"
s = "Purple"
s = "Blue"
stringlist end

stringlist = _commentListResID,"Help tags"
s = "Lime is luscious."
s = "Tangerine is Tangy."
s = "Strawberry is Super!"
s = "Grape is grand."
s = "Blueberry is nice."
stringlist end

end fn

'~'1
/*
     Display an alert just to show something on screen
*/
clear local fn ShowMe( message as Str255 )

dim as AlertStdAlertParamRec  alertParams
dim as SInt16               @ itemHit

alertParams.movable       = _true
alertParams.helpButton    = _false
alertParams.filterProc    = _nil'TEventDispatcher::ModalFilter()
alertParams.defaultText   = _kAlertDefaultOKText
alertParams.cancelText    = _nil
alertParams.otherText     = _nil
alertParams.defaultButton = _kAlertStdAlertOKButton
alertParams.cancelButton  = 0
alertParams.position      = _kWindowDefaultPosition

end fn = fn StandardAlert( _kAlertPlainAlert, message, _nil, alertParams, itemHit )

'~';
'~--
'~Application Functions
/*
     Those are functions avoiding to repeat test code elsewhere.
     They check if a given item must be shown as an alias in the list
     and if a given item is a container (i.e. has subitems)
*/
def fn IsAlias( itemID ) = ( itemID == 44 || itemID == 486 || itemID == 509 )
def fn IsContainer( itemID ) = ( not( ( (itemID mod 5) == 2 or itemID > 10000) ) and not( fn IsAlias( itemID ) ) )

'~';
/*
     This function is used to create a string, it is used more precisely
     for the cells under the column titled ItemID that the DataBrowser
     must display.
*/
clear local fn GenerateString( itemID as DataBrowserItemID, inProp as DataBrowserPropertyID, @s as .Str255 )

dim as Str255                  tempStr
dim as DataBrowserPropertyID @ prop
dim as Boolean                 itemXProperty

prop = inProp
s.nil` = 0
itemXProperty = ( prop == _itemIDColumnID or prop == _kDataBrowserItemSelfIdentityProperty )

if itemXProperty then s.nil$ = "Item "
s.nil$ = s.nil$ + str$( itemID )

long if not( itemXProperty )
tempStr[0] = sizeof(prop)
BlockMoveData( @prop, @tempStr[1], sizeof(prop) )
s.nil$ = s.nil$ + ", " + tempStr
end if

end fn

'~'1
/*
     This function retrieves the browser reference from the window.
     The browser reference has been saved has a window property.
*/
clear local fn GetDataBrowserFromWindow( w as WindowRef )

dim as OSStatus     err
dim as ControlRef @ browser

long if w
err = fn GetWindowProperty( w, _myCreator, _myDataBrowser, sizeof(browser), #_nil, browser )
end if

end fn = browser

'~Customizer & Settings Dialogs
'~';
/*
     This function will tell if a given feature is enabled for the
     selection mode used with the DataBrowser.
     The selection flags can be a combination of the following:

          constant name                                   description

     _kDataBrowserDragSelect             This turns on or off the availability of the
                                         selection marque. The marque will show up if
                                         the click was not on content, or the Option key
                                         is not down and _kDataBrowserDragSelect is on
                                         _kDataBrowserSelectOnlyOne is off and
                                         _kDataBrowserNoDisjointSelection is off.

     _kDataBrowserSelectOnlyOne          allow only one item to be selected at once.

     _kDataBrowserResetSelection         reset list before processing next selection
                                         operation.

     _kDataBrowserCmdTogglesSelection    allow use of command to toggle items in and
                                         out of the selection.

     _kDataBrowserNoDisjointSelection    prevent discontinuous selections.

     _kDataBrowserAlwaysExtendSelection  enable multiple item selection without holding
                                         down any modifier keys.

*/
clear local fn SelectionFlagOn( browser as ControlRef, flag as DataBrowserSelectionFlags )

dim as DataBrowserSelectionFlags @ flags
dim as OSStatus                    err

long if browser
err = fn GetDataBrowserSelectionFlags( browser, flags )
end if

end fn = ( flags and flag ) <> 0// I hope it is OK

'~';
/*
     This function will setup the buttons in the customizer windows.
     There are two dialogs to play with the DataBrowser settings
     in this program.
*/
clear local fn SetupControls( dlog as DialogRef, customizerID as UInt16)

dim as OSStatus                          err
dim as DialogItemIndex                   dItem
dim as ControlRef                        browser, @ c
dim as UInt32                          @ numColumns
dim as UInt16                          @ headerBtnHeight
dim as DataBrowserPropertyFlags        @ flags
dim as DataBrowserTableViewHiliteStyle @ hiliteStyle
dim as DataBrowserPropertyID           @ disclosureColumn
dim as Boolean                         @ cVal, vBar, hBar, expandableRows

browser  = fn GetDataBrowserFromWindow( fn GetDialogWindow(dlog) )

do
dItem++
if fn GetDialogItemAsControl( dlog, dItem, c ) != _noErr then exit do

long if c
// Set a custom ID for each control's reference (here its index in the control list)
SetControlReference( c, dItem )

select customizerID

case _settingsDLOGResID:
'~'2

select dItem

case _activeItemsBtn  : err = fn GetDataBrowserActiveItems( browser, cVal )
case _frameAndFocusBtn: err = fn GetControlData( browser, _kControlNoPart, _kControlDataBrowserIncludesFrameAndFocusTag, sizeof(cVal), cVal, #_nil)
case _verticalScrollBtn, _horizontalScrollBtn:

err = fn GetDataBrowserHasScrollBars( browser, hBar, vBar )
select dItem
case _verticalScrollBtn  : cVal = vBar
case _horizontalScrollBtn: cVal = hBar
end select

case _dragSelectBtn    : cVal = fn SelectionFlagOn( browser, _kDataBrowserDragSelect )
case _selectOnlyOneBtn : cVal = fn SelectionFlagOn( browser, _kDataBrowserSelectOnlyOne )
case _resetSelectionBtn: cVal = fn SelectionFlagOn( browser, _kDataBrowserResetSelection )
case _commandTogglesBtn: cVal = fn SelectionFlagOn( browser, _kDataBrowserCmdTogglesSelection )
case _noDisjointBtn    : cVal = fn SelectionFlagOn( browser, _kDataBrowserNoDisjointSelection )
case _alwaysExtendBtn  : cVal = fn SelectionFlagOn( browser, _kDataBrowserAlwaysExtendSelection )

end select

case _customizeDLOGResID:
'~'2

select dItem

case _varHeightRowsBtn:

err = fn GetDataBrowserTableViewGeometry( browser, #_nil, cVal )
/*
     fn GetDataBrowserTableViewGeometry ( browser, variableWidthColumns, variableHeightRows )

     variableWidthColumns     true if the DataBrowser has variable
                              width columns

     variableHeightRows       true if the DataBrowser has variable
                              height rows (currently ignored)
*/
long if cVal = _false
err = fn GetDialogItemAsControl( dlog, _expandableRowsBtn, c )
err = fn DeactivateControl( c )
end if

case _disclosureBtn, _expandableRowsBtn:

err = fn GetDataBrowserListViewDisclosureColumn( browser, disclosureColumn, expandableRows )
/*
     disclosureColumn   the column Property ID of the column where
                        the disclosure triangles are being displayed.

     expandableRows     if the row itself expands rather than opening up
                        several sub-rows, then this parameter will be
                        set to true.
*/

long if dItem != _disclosureBtn
cVal = expandableRows
xelse
long if disclosureColumn
// setup the value for the popup menu control
err = fn GetDataBrowserTableViewColumnCount( browser, numColumns )
while numColumns
numColumns--
if disclosureColumn == gCols(numColumns) then cVal = numColumns + 3 : exit while
wend
end if
end if

case _useRelativesDatesBtn:

err  = fn GetDataBrowserPropertyFlags( browser, _dateTimeColumnID, flags )
cVal = flags and _kDataBrowserDateTimeRelative

case _fillHiliteStyleBtn:

err  = fn GetDataBrowserTableViewHiliteStyle( browser, hiliteStyle )
cVal = hiliteStyle

case _showHeaderButtonsBtn:
err  = fn GetDataBrowserListViewHeaderBtnHeight( browser, headerBtnHeight )
cVal = abs( headerBtnHeight != 0 )// ABS needed because _zTrue (-1) won't work

case _plainBackgroundBtn:
err = fn GetDataBrowserListViewUsePlainBackground( browser, cVal )

end select

end select

SetControlValue( c, cVal )

end if

until _nil// loop exit on error

end fn

'~';
/*
     This function will return the dialogRef of one of the two
     customizer windows. The dialogRef has previously been stored
     as a browser property.
*/
clear local fn GetCustomizer( browser as ControlRef, customizerID as UInt16 )

dim as OSStatus    err
dim as DialogRef @ customizer

long if browser
err = fn GetControlProperty( browser, _myCreator, customizerID, sizeof(customizer), #_nil, customizer )
end if

end fn = customizer

'~';
/*
     Given a customizer window reference the function will
     return the customizer ID.
*/
clear local fn GetCustomerID( customizer as WindowRef )

dim as OSStatus err
dim as UInt16 @ customizerID

long if customizer
err = fn GetWindowProperty( customizer, _myCreator, _myCustomizerID, sizeof(customizerID), #_nil, customizerID )
end if

end fn = customizerID

'~';
/*
     This function will display or create our two dialogs for
     customization.
*/
clear local fn SetupCustomizer( inBrowser as ControlRef, inCustomizerID as UInt16 )

dim as OSStatus       err
dim as WindowRef      w
dim as DialogRef    @ customizer
dim as UInt16       @ customizerID
dim as proc         @ eventHandler
dim as ControlRef   @ browser
dim as EventTypeSpec  events(3)

browser      = inBrowser// RAM variable needed
customizerID = inCustomizerID// idem

/*
     Get the customizer (DialogRef) with the customizerID (custom identifier)
     previously stored as a control property for the DataBrowser
*/
customizer   = fn GetCustomizer( browser, customizerID )

long if customizer == _nil// this customizer is not currently open

customizer = fn GetNewDialog( customizerID, _nil, -1 )

long if customizer
w          = fn GetDialogWindow( customizer )
err        = fn InstallStandardEventHandler( fn GetWindowEventTarget( w ) )

// Store our custom dialog identifier as a browser property
err = fn SetControlProperty( browser, _myCreator, customizerID, sizeof(customizer), customizer )

// Store browser as a property of that dialog window
err = fn SetWindowProperty( w, _myCreator, _myDataBrowser, sizeof(ControlRef), browser )

// Setup initial control values
fn SetupControls( customizer, customizerID )
err = fn SetWindowClass( w, _kFloatingWindowClass )

// Store event handler as a window property
events.eventClass(0) = _kEventClassWindow
events.eventKind (0) = _kEventWindowClose

events.eventClass(1) = _kEventClassControl
events.eventKind (1) = _kEventControlHit

events.eventClass(2) = _kEventClassCommand
events.eventKind (2) = _kEventCommandProcess

events.eventClass(3) = _kEventClassCommand
events.eventKind (3) = _kEventCommandUpdateStatus

eventHandler = fn NewEventHandlerUPP( [proc "DialogEventHandlerProc" + _FBprocToProcPtrOffset] )

long if fn InstallWindowEventHandler( w, eventHandler, sizeof(events(0))*4, events(0), #_nil, #_nil )
DisposeDialog( customizer ) : exit fn
end if

err = fn SetWindowProperty( w, _myCreator, _myEventHandler, sizeof(eventHandler), eventHandler )
// Store customizerID as a window property
err = fn SetWindowProperty( w, _myCreator, _myCustomizerID, sizeof(customizerID), customizerID )
end if

xelse

w = fn GetDialogWindow( customizer )
ShowWindow( w )
SelectWindow( w )

end if

end fn

'~';
/*
     Some checkboxes are linked together in the settings dialog, this function
     will activate or deasctivate controls depending on the current value
     set for another one.
*/
clear local fn ActivateControlInDialog( dlog as DialogRef, dItem as UInt8, numItems as UInt8, items(_maxint) as UInt8 )

dim as ControlRef @ c
dim as OSStatus     err
dim as long         i
dim as boolean      active

for i = 0 to numItems - 1
long if fn GetDialogItemAsControl( dlog, items(i), c ) = _noErr
active = fn GetControlValue( c )
end if
if active then exit for
next

long if fn GetDialogItemAsControl(  dlog, dItem, c ) = _noErr
long if active
err = fn DeactivateControl( c )
xelse
err = fn ActivateControl( c )
end if
end if

end fn

'~';
/*
     This function checks if a given flag is enabled for the DataBrowser
     then update the value of a given button accordingly.
*/
clear local fn ToggleSelectionFlag( browser as ControlRef, flag as DataBrowserSelectionFlags, c as ControlRef )

dim as DataBrowserSelectionFlags @ flags
dim as OSStatus                    err

err = fn GetDataBrowserSelectionFlags( browser, flags )
err = fn SetDataBrowserSelectionFlags( browser, flags xor flag )

//Make sure flag and representative control are synch'd
long if flags and flag
SetControlValue( c, _kThemeButtonOff )
xelse
SetControlValue( c, _kThemeButtonOn )
end if

end fn// = not( flags and flag )

'~';
/*
     This is where the action are triggered for our two dialogs
     for costumization. It will update the features of the
     DataBrowser according to the selection of the end user.
*/
clear local fn HandleCustomizerControl( inCntl as ControlRef )

dim as WindowRef                  w
dim as DialogItemIndex            dItem
dim as ControlRef                 browser, @ cmdTogglesCntrl, c
dim as DialogRef                  dlog
dim as OSStatus                   err
dim as Rect                       sInset
dim as UInt16                  @  headerBtnHeight
dim as ThemeButtonValue           value
dim as UInt8                      i
dim as UInt8                      dragSelectOverrides(1)
dim as UInt8                      alwaysExtendOverrides(1)
dim as UInt8                      overrides(3)
dim as DataBrowserPropertyFlags @ flags
dim as DataBrowserPropertyID    @ disclosureColumn
dim as Boolean                  @ cVal, expandableRows, vBar, hBar, bool

c       = inCntl// local copy of the controlRef for RAM variable
w       = fn GetControlOwner( c )// windowRef of the window owning the control
cVal    = fn GetControlValue( c )// current control value
dItem   = fn GetControlReference( c )// get our custom identifier for that control
browser = fn GetDataBrowserFromWindow( w )// get the DataBrowser control from the windowRef

select fn GetCustomerID( w )// which custom identifer for that dialog window

case _customizeDLOGResID:
'~'2

select dItem

case _disclosureBtn, _expandableRowsBtn:// 2 controls treated here

err = fn GetDataBrowserListViewDisclosureColumn( browser, disclosureColumn, expandableRows )
long if dItem != _disclosureBtn
expandableRows = cVal
xelse
long if cVal < 3// cVal is the popup menu item chosen
disclosureColumn = _kDataBrowserItemNoProperty
xelse
disclosureColumn = gCols(cVal-3)
end if
end if
err = fn SetDataBrowserListViewDisclosureColumn( browser, disclosureColumn, expandableRows )

case _showHeaderButtonsBtn:

err  = fn GetDataBrowserListViewHeaderBtnHeight( browser, headerBtnHeight )
select
case cVal != 0 and headerBtnHeight == 0 : headerBtnHeight = _btnHeight // checked "Show Headers" checkbox and header currently invisible
case cVal == 0 and headerBtnHeight != 0 : headerBtnHeight = 0// unchecked "Show Headers" checkbox and header currently visible
end select
err = fn SetDataBrowserListViewHeaderBtnHeight( browser, headerBtnHeight )

case _fillHiliteStyleBtn:

err = fn SetDataBrowserTableViewHiliteStyle( browser, cVal )// pass just the "Fill Hilite" checkbox value to the DataBrowser

case _useRelativesDatesBtn:

err = fn GetDataBrowserPropertyFlags( browser, _dateTimeColumnID, flags )// just toggle the current flag
err = fn SetDataBrowserPropertyFlags( browser, _dateTimeColumnID, flags xor _kDataBrowserDateTimeRelative )

case _varHeightRowsBtn:
/*
 GetDataBrowserTableViewGeometry (browser, variableWidthColumns, variableHeightRows)
*/

err = fn GetDataBrowserTableViewGeometry( browser, bool, cVal )
err = fn SetDataBrowserTableViewGeometry( browser, bool, -(cVal == 0) )//not(cVal)

SetControlValue( c, -(cVal == 0) )//not(cVal)

err = fn GetDialogItemAsControl( fn GetDialogFromWindow( fn GetControlOwner( c ) ), _expandableRowsBtn, c )

long if cVal
err = fn ActivateControl( c )
xelse
err = fn DeactivateControl( c )
end if

case _plainBackgroundBtn:
err = fn SetDataBrowserListViewUsePlainBackground( browser, cVal )

end select


case _settingsDLOGResID:
'~'2

dlog = fn GetDialogFromWindow( w )

select dItem

case _frameAndFocusBtn:

err = fn SetControlData( browser, _kControlNoPart, _kControlDataBrowserIncludesFrameAndFocusTag, sizeof(cVal), cVal )

case _activeItemsBtn:

err = fn SetDataBrowserActiveItems( browser, cVal )

case _verticalScrollBtn, _horizontalScrollBtn:

err = fn GetDataBrowserHasScrollBars( browser, hBar, vBar )

select dItem
case _verticalScrollBtn  : if vBar then vBar = _false else vBar = _true
case _horizontalScrollBtn: if hBar then hBar = _false else hBar = _true
end select

err = fn SetDataBrowserHasScrollBars( browser, hBar, vBar )

long if hBar or vBar
err = fn GetDataBrowserScrollBarInset( browser, sInset )
if hBar then sInset.right  = _scrollBarWidth - 1
if vBar then sInset.bottom = _scrollBarWidth - 1
err = fn SetDataBrowserScrollBarInset( browser, sInset )
end if

case _dragSelectBtn      : fn ToggleSelectionFlag( browser, _kDataBrowserDragSelect, c )
case _selectOnlyOneBtn   : fn ToggleSelectionFlag( browser, _kDataBrowserSelectOnlyOne, c )
case _resetSelectionBtn  : fn ToggleSelectionFlag( browser, _kDataBrowserResetSelection, c )
case _commandTogglesBtn  : fn ToggleSelectionFlag( browser, _kDataBrowserCmdTogglesSelection, c )
case _noDisjointBtn      : fn ToggleSelectionFlag( browser, _kDataBrowserNoDisjointSelection, c )
case _alwaysExtendBtn    : fn ToggleSelectionFlag( browser, _kDataBrowserAlwaysExtendSelection, c )

/*
case _noEmptySelectionBtn: fn ToggleSelectionFlag( browser, _kDataBrowserNeverEmptySelectionSet, c )
*/
end select

/*
     A few checkboxes are linked together, so the following
     piece of code overrides the end user selection.
*/
select dItem

case _noDisjointBtn, _selectOnlyOneBtn, _resetSelectionBtn, _commandTogglesBtn, _noEmptySelectionBtn:

dragSelectOverrides(0) = _noDisjointBtn
dragSelectOverrides(1) = _selectOnlyOneBtn
fn ActivateControlInDialog( dlog, _dragSelectBtn, 2, @dragSelectOverrides(0) )

alwaysExtendOverrides(0) = _selectOnlyOneBtn
alwaysExtendOverrides(1) = _resetSelectionBtn
fn ActivateControlInDialog( dlog, _alwaysExtendBtn, 2, @alwaysExtendOverrides(0))

long if fn GetDialogItemAsControl( dlog, _commandTogglesBtn, cmdTogglesCntrl) = _noErr
long if fn GetControlValue( cmdTogglesCntrl )
value = _kThemeButtonOn
overrides(0) = _noDisjointBtn
overrides(1) = _selectOnlyOneBtn
overrides(2) = _resetSelectionBtn
overrides(3) = _noEmptySelectionBtn
for i = 0 to 3
long if fn GetDialogItemAsControl( dlog, overrides(i), c ) = _noErr
if fn GetControlValue( c ) then value = _kThemeButtonMixed : exit for
end if
next
SetControlValue( cmdTogglesCntrl, value )
end if
end if

end select

end select

end fn

'~-----
'~DataBrowser Drag & Drop
/*
     This function tells the DataBrowser if a dragged item is
     acceptable or not. It is invoked via a specific callback procedure.
*/
clear local fn MyAcceptDrag( browser as ControlRef, theDrag as DragReference, itemID as DataBrowserItemID )

dim as ThemeCursor         curs
dim as OSStatus            err
dim as SInt16            @ modifiers
dim as DataBrowserItemID @ target
dim as boolean             accept

accept = fn IsContainer( itemID )

long if accept
curs  = _kThemeArrowCursor
err   = fn GetDragModifiers( theDrag, modifiers, #_nil, #_nil )

select

case ( modifiers and _cmdKey%_optionKey% ) =  _cmdKey%_optionKey%: curs = _kThemeAliasArrowCursor
case ( modifiers and _optionKey% )         = _optionKey%         : curs = _kThemeCopyArrowCursor

case ( modifiers and _cmdKey% ) = _cmdKey% :
target = _kDataBrowserNoItem
err    = fn GetDataBrowserTarget( browser, target )
if ( itemID != target ) then accept = _false

end select

err = fn SetThemeCursor( curs )
end if

end fn = accept

'~';
/*
     This function is called via a callback procedure, when an
     item has been dropped somewhere in the list. The itemID
     holds the target container, the item/s beeing dropped is/are
     retrieved from the drag reference.

     The state of the target container can be examined with:

     GetDataBrowserItemState( browser, itemID, itemState )

      The possible states are:

          constant name                     description
     _kDataBrowserItemNoState       has no state associated with it at this time.
     _kDataBrowserItemIsSelected    is a member of the current selection.
     _kDataBrowserContainerIsOpen   disclosure open.
     _kDataBrowserItemIsDragTarget  Only true during a drag operation.
*/
clear local fn MyReceiveDrag( browser as ControlRef, theDrag as DragReference, itemID as DataBrowserItemID )

dim as UInt32                 i
dim as OSStatus               err
dim as Size                 @ dataSize
dim as DataBrowserItemID    @ draggedItem
dim as ItemReference        @ itemRef
dim as UInt16               @ numItems
dim as DataBrowserItemState @ itemState

itemState = 0

long if itemID == _kDataBrowserNoItem// dropped over nothing
itemState = _kDataBrowserContainerIsOpen// in that test we'll accept only on open containers
xelse
err = fn GetDataBrowserItemState( browser, itemID, itemState )// get the state of the target container
end if

long if itemState and _kDataBrowserContainerIsOpen

err = fn CountDragItems( theDrag, numItems )
long if numItems
for i = 1 to numItems
dataSize = sizeof(draggedItem)
err   = fn GetDragItemReferenceNumber( theDrag, i, itemRef )
err   = fn GetFlavorData( theDrag, itemRef, _typeUInt32, draggedItem, dataSize, 0 )
err   = fn RemoveDataBrowserItems( browser, _kDataBrowserNoItem, 1, draggedItem, _kDataBrowserItemNoProperty )
err   = fn AddDataBrowserItems( browser, itemID, 1, draggedItem, _kDataBrowserItemNoProperty )
next
end if

// Rem'd out in the original Apple demo
dim as Str255  s
s = "Drag received in "
select itemID
case _nil : s += "list"
case else : s += "Item " + str$( itemID )
end select
fn ShowMe( s )

end if

end fn = _true

'~'1
/*
     This function is invoked by a callback procedure, to let you
     add an item for the drag operation.
*/
clear local fn MyAddDragItem( browser as ControlRef, theDrag as DragReference, inItemID as DataBrowserItemID, itemRef as .ItemReference )

dim as Str255              s
dim as OSStatus            err
dim as DataBrowserItemID @ itemID

itemID  = inItemID// must be in RAM

fn GenerateString( itemID, _"col4", s )
s += chr$(13)

err = fn GetDragItemReferenceNumber( theDrag, 1, #itemRef )
err = fn AddDragItemFlavor( theDrag, itemRef.nil&, _"TEXT", @s[1], s[0], 0 )
err = fn AddDragItemFlavor( theDrag, itemRef.nil&, _typeUInt32, @itemID, sizeof(itemID), 0 )

end fn = _true // for automatic transluscent dragging

'~DataBrowser Setting & Getting Data
'~'1
/*
     This function is called via a callback procedure. This is
     the only required routine to work with a DataBrowser control.
     The DataBrowser asks you to setup some values for the cells
     that it must display. Those values are set with specific functions
     depending on the type of the cell to be updated.
     With the same callback routine the DataBrowser may inform you
     that a cell has been changed by the end user, so it is time
     to get the value sent by the DataBrowser to update your
     internal information.
     Here, we don't have a real set of items to update, since
     they are faked with calculation.
*/
clear local fn MyGetSetItemData( browser as ControlRef, itemID as DataBrowserItemID, prop as DataBrowserPropertyID, itemData as DataBrowserItemDataRef, changeValue as Boolean )

dim as OSStatus    err
dim as CFStringRef txt
dim as SInt16      mod5
dim as Str255      s
dim as LongDateCvt dt

err = _noErr

long if changeValue = _false

select prop


case _checkboxColumnID:

long if ( itemID mod 5 ) == 2
err = fn SetDataBrowserItemDataButtonValue( itemData, _kThemeButtonMixed )
err = fn SetDataBrowserItemDataDrawState( itemData, _kThemeStateInactive )
end if


case _flavorColumnID, _iconOnlyColumnID

long if prop == _flavorColumnID// Fall through to _iconOnlyColumnID
s   = str#( _flavorListResID, ( itemID mod 5 ) + 1 )
txt = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, s, _kCFStringEncodingMacRoman )
err = fn SetDataBrowserItemDataText( itemData, txt ) : CFRelease( txt )
end if

long if fn IsContainer( itemID )
err = fn SetDataBrowserItemDataIcon( itemData, gIcon(_folderIndex) )
xelse
long if fn IsAlias( itemID )
err = fn SetDataBrowserItemDataIcon( itemData, gIcon(_folderAliasIndex) )
xelse
err = fn SetDataBrowserItemDataIcon( itemData, gIcon(_documentIndex) )
end if
end if


case _colorColumnID:

s   = str#( _colorListResID, ( itemID mod 5 ) + 1 )
txt = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, s, _kCFStringEncodingMacRoman )
err = fn SetDataBrowserItemDataText( itemData, txt ) : CFRelease( txt )


case _indexColumnID:

mod5 = itemID mod 5
if mod5 == 0 then mod5 = 5
NumToString( mod5, s )
txt = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, s, _kCFStringEncodingMacRoman )
err = fn SetDataBrowserItemDataText( itemData, txt ) : CFRelease( txt )


case _dateTimeColumnID:

dt.hl.lHigh = 0
GetDateTime( dt.hl.lLow )
dt.hl.lLow -= ( ( (itemID - 1) mod 10 ) * 28800 )
err = fn SetDataBrowserItemDataLongDateTime( itemData, dt.c )


case _sliderColumnID, _progressColumnID:

err = fn SetDataBrowserItemDataValue( itemData, ( itemID mod 5 ) * 20 )


case _popupMenuColumnID:

long if ( itemID mod 5 + 1 ) != 1
err = fn SetDataBrowserItemDataMenuRef( itemData, gContextualMenu )
end if
err = fn SetDataBrowserItemDataValue( itemData, ( itemID mod 5 ) + 1 )


case _kDataBrowserItemSelfIdentityProperty, _itemIDColumnID

long if prop == _kDataBrowserItemSelfIdentityProperty// can display icon & text, so fall through to text generator
select
case fn IsContainer( itemID ) : err = fn SetDataBrowserItemDataIcon( itemData, gIcon(_folderIndex)      )
case fn IsAlias( itemID )     : err = fn SetDataBrowserItemDataIcon( itemData, gIcon(_folderAliasIndex) )
case else                     : err = fn SetDataBrowserItemDataIcon( itemData, gIcon(_documentIndex)    )
end select
end if

fn GenerateString( itemID, prop, s ) // case _itemIDColumnID
txt = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, s, _kCFStringEncodingMacRoman )
err = fn SetDataBrowserItemDataText( itemData, txt ) : CFRelease( txt )


case _kDataBrowserItemIsActiveProperty:

if ( itemID mod 5 ) == 3 then err = fn SetDataBrowserItemDataBooleanValue( itemData, _false )


case _kDataBrowserItemIsEditableProperty:

err = fn SetDataBrowserItemDataBooleanValue( itemData, _true )


case _kDataBrowserItemIsContainerProperty:

err = fn SetDataBrowserItemDataBooleanValue( itemData, fn IsContainer( itemID ) )


case _kDataBrowserContainerAliasIDProperty:

if fn IsAlias( itemID ) then err = fn SetDataBrowserItemDataItemID( itemData, 4 )


case _kDataBrowserItemParentContainerProperty:
err = fn SetDataBrowserItemDataItemID( itemData, ( itemID-1 ) / _itemsPerContainer )


case else:

err = _errDataBrowserPropertyNotSupported

end select

xelse
/*
     The end user has altered the cell if we come here.
     For testing with the color column
*/
select prop

case  _colorColumnID
dim as CFStringRef    @ newTxt

err = fn GetDataBrowserItemDataText( itemData, newTxt )
err = fn CFStringGetPascalString(newTxt, @s, 256, _kCFStringEncodingMacRoman )
if newTxt then CFRelease( newTxt )

s = "Not shown in this demo. Data changed : Item:" + str$( itemID ) + "; Value: " + s
fn ShowMe( s )

case else : err = _errDataBrowserPropertyNotSupported

end select

end if

end fn = err

'~'1
'~DataBrowser Custom Sorting
/*
     This function is called via a callback procedure.
     Sometimes the DataBrowser doesn't know how to deal with
     certain data when it needs to sort the list. You can provide
     a custom sort routine in that scenario.
*/
clear local fn MyItemComparison( browser as ControlRef, ┬
                           itemOneID as DataBrowserItemID, ┬
                           itemTwoID as DataBrowserItemID, ┬
                         sortProperty as DataBrowserPropertyID)

dim as SInt16   compareResult
dim as SInt32   val1, val2
dim as Str255   s1, s2
dim as boolean  result

select sortProperty

case _flavorColumnID:

s1 = str#( _flavorListResID, itemOneID mod 5 + 1 )
s2 = str#( _flavorListResID, itemTwoID mod 5 + 1 )
compareResult = fn CompareString( s1, s2, _nil )

select compareResult
case < 0  : result = _true
case > 0  : result = _false
case else : result = fn MyItemComparison( _nil, itemOneID, itemTwoID, _"????" )
end select

case _colorColumnID:

s1 = str#( _colorListResID, itemOneID mod 5 + 1 )
s2 = str#( _colorListResID, itemTwoID mod 5 + 1 )
compareResult = fn CompareString( s1, s2, _nil )

select compareResult
case < 0  : result = _true
case > 0  : result = _false
case else : result = fn MyItemComparison( _nil, itemOneID, itemTwoID, _"foo " )
end select

case _progressColumnID:

val1 = (itemOneID mod 5) * 20
val2 = (itemTwoID mod 5) * 20

select
case val1 < val2 : result = _true
case val1 > val2 : result = _false
case else        : result = fn MyItemComparison( _nil, itemOneID, itemTwoID, _"????" )
end select

case else: result = ( itemOneID < itemTwoID )

end select

end fn = result

'~'1
'~DataBrowser Notification
/*
     This function is invoked by a callback procedure. The DataBrowser
     control can notify the program of interesting things happening.

          Constant Name                                  Description
     _kDataBrowserItemAdded             The specified item has been added to the browser.
     _kDataBrowserItemRemoved           The specified item has been removed from the browser.
     _kDataBrowserEditStarted           Starting an EditText session for specified item.
     _kDataBrowserEditStopped           Stopping an EditText session for specified item.
     _kDataBrowserItemSelected          Item has just been added to the selection set.
     _kDataBrowserItemDeselected        Item has just been removed from the selection set.
     _kDataBrowserItemDoubleClicked     The user double clicked on an item.
     _kDataBrowserContainerOpened       Container has been opened.
     _kDataBrowserContainerClosing      Container is about to close.
     _kDataBrowserContainerClosed       Container has been closed.
     _kDataBrowserContainerSorting      Container is about to be sorted (lock any volatile properties).
     _kDataBrowserContainerSorted       Container has been sorted (you may release any property locks).
     _kDataBrowserTargetChanged         The target has changed to the specified item.
     _kDataBrowserUserStateChanged      The user has reformatted the view for the target.
     _kDataBrowserSelectionSetChanged   The selection set has been modified (net result may be the same).
*/
clear local fn MyItemNotification( browser as ControlRef, itemID as DataBrowserItemID, message as DataBrowserItemNotification )

dim as OSStatus            err
dim as UInt32              i
dim as DataBrowserItemID   myItems(_itemsPerContainer)
dim as Boolean           @ variableHeightRows

select message

//err = fn SetDataBrowserItemDataButtonValue( itemData, _kThemeButtonOn )

//     Rem'd out in the Apple demo
//case _kDataBrowserItemSelected:

//dim as Handle  @ h
//dim as UInt32   numSelectedItems

//h = fn NewHandle( 0 )
//err = fn GetDataBrowserItems( browser,  _kDataBrowserNoItem, true, _kDataBrowserItemIsSelected, h )
//numSelectedItems = fn GetHandleSize( h ) / sizeof(DataBrowserItemID)

case _kDataBrowserContainerOpened: // Generate some valid itemIDs

for i = 0 to _itemsPerContainer - 1
myItems(i) = itemID * _itemsPerContainer + i + 1
next

err = fn AddDataBrowserItems( browser, itemID, _itemsPerContainer, myItems(0), _indexColumnID )

// Set up variable height rows
err = fn GetDataBrowserTableViewGeometry( browser, #_nil, variableHeightRows )

long if variableHeightRows
for i = 0 to _itemsPerContainer - 1
err = fn SetDataBrowserTableViewItemRowHeight( browser, myItems(i), 20 + ( myItems(i) - 1 ) mod 10 * 3 )
next
end if

case _kDataBrowserSelectionSetChanged:
DrawOneControl(gPlacard)

end select

end fn

'~'1
'~DataBrowser Help Tags
/*
     This function is invoked by a callback procedure when it is
     time for the program to provide help content for help tags.
*/
clear local fn MyItemHelpContent( browser as ControlRef, item as DataBrowserItemID, prop as DataBrowserPropertyID, inRequest as HMContentRequest, outContentProvided as .HMContentProvidedType, ioHelpContent as .HMHelpContentRec )

dim as HMHelpContent helpContent // temporary HMHelpContent record
dim as Boolean       helpContentProperty

helpContentProperty = ( prop == _flavorColumnID ) or ( prop == _kDataBrowserItemSelfIdentityProperty )

long if ( inRequest == _kHMSupplyContent and ( item != _kDataBrowserNoItem ) and helpContentProperty )
outContentProvided.nil% = _kHMContentProvided
helpContent.contentType = _kHMStringResContent
helpContent.tagStringRes.hmmIndex = item mod 5 + 1
helpContent.tagStringRes.hmmResID = _commentListResID
//ioHelpContent.content[_kHMMaximumContentIndex] = helpContent
ioHelpContent.content[0] = helpContent
end if

end fn

'~'1
'~DataBrowser Contextual Menu
/*
     This function is called via a callback procedure when the
     DataBrowser needs a contextual menu to display.
*/
clear local fn MyGetContextualMenu( browser as ControlRef, @contextualMenu as .MenuRef, helpType as .UInt32, @helpItemString as .CFStringRef, selection as .AEDesc )

helpItemString.nil& = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, "Testing 1-2-3", _kCFStringEncodingMacRoman)
helpType.nil&       = _kCMHelpItemOtherHelp

long if gContextualMenu
contextualMenu.nil& = gContextualMenu
xelse
contextualMenu.nil& = fn GetMenu( _contextualMenuResID )
InsertMenu( contextualMenu.nil&, -1 )
end if

end fn

'~'1
/*
     This function is called by the DataBrowser via a callback
     routine when the end user has chosen an item in a contextual menu.
*/
clear local fn MySelectContextualMenu( browser as ControlRef, contextualMenu as MenuRef, selectionType as UInt32, menuID as SInt16, menuItem as MenuItemIndex )

dim as str255 s

GetMenuItemText( contextualMenu, menuItem, s )
long if gContextualMenu = _nil
DeleteMenu( _contextualMenuResID )
DisposeMenu( contextualMenu )
end if

fn ShowMe( s )

end fn

'~DataBrowser Placard Drawing
'~'1
/*
     This function is called by a callback procedure installed
     in a placard control, so that it updates itself at the
     right location on screen with the right info.
*/
clear local fn MyPlacardDraw( c as ControlRef, dummy as SInt16 )

dim as OSStatus     err
dim as ControlRef   browser
dim as Str255       s, placardStr
dim as UInt32     @ numSelectedItems
dim as Rect         r

browser = fn GetControlReference( c )
s = " Items Selected"
long if browser
GetControlBounds( browser, r )
r.top   = r.bottom - 15
r.right = r.left + 100

err = fn GetDataBrowserItemCount( browser, _kDataBrowserNoItem, _true, _kDataBrowserItemIsSelected, numSelectedItems )
NumToString( numSelectedItems, placardStr )
BlockMoveData( @s[1], @placardStr[placardStr[0]+1], s[0] )
placardStr[0] += s[0]

long if fn IsControlActive( c )
err = fn DrawThemePlacard( r, _kThemeStateActive )
err = fn SetThemeTextColor( _kThemeTextColorPlacardActive, 8, _true )
xelse
err = fn DrawThemePlacard( r, _kThemeStateInactive )
err = fn SetThemeTextColor( _kThemeTextColorPlacardInactive, 8, _true )
end if

err = fn UseThemeFont( _kThemeSmallSystemFont, _smSystemScript )
MoveTo( r.left + (r.right - r.left)/2 - fn StringWidth( placardStr )/2, r.bottom - 4)
DrawString( placardStr )
end if

end fn

'~';
'~--------
'~DataBrowser Installing
/*
     After creating the DataBrowser, you need to configure it.
     That is to say to define columns and their properties.
     Here are the tcolumn types you can use:

          constant names                 cell's contents are set with
     _kDataBrowserCustomType        No associated data, must use custom callbacks
     _kDataBrowserIconType          IconRef, IconTransformType, RGBColor
     _kDataBrowserTextType          CFStringRef
     _kDataBrowserDateTimeType      DateTime or LongDateTime
     _kDataBrowserSliderType        Min, Max, Value
     _kDataBrowserCheckboxType      ThemeButtonValue
     _kDataBrowserProgressBarType   Min, Max, Value
     _kDataBrowserRelevanceRankType Min, Max, Value
     _kDataBrowserPopupMenuType     MenuRef, Value
     _kDataBrowserIconAndTextType   IconRef, CFStringRef, etc

*/
clear local fn ConfigureDataBrowser( browser as ControlRef )

dim as OSStatus                       err
dim as str15                          cr
dim as Rect                           insR
dim as DataBrowserListViewColumnDesc  colDesc
dim as DataBrowserViewStyle         @ viewStyle

cr = chr$( 13 )

#if ndef _kDataBrowserListViewAppendColumn
_kDataBrowserListViewAppendColumn = 4294967295 // _ULONG_MAX defined in ANSI Headers (limits.h)
#endif

err = fn GetDataBrowserViewStyle( browser, viewStyle )
err = fn GetDataBrowserScrollBarInset( browser, insR )
insR.right = _scrollBarWidth - 1
err = fn SetDataBrowserScrollBarInset( browser, insR )

select viewStyle

case _kDataBrowserListView:

colDesc.headerBtnDesc.titleOffset        = 0
colDesc.headerBtnDesc.version            = _kDataBrowserListViewLatestHeaderDesc
colDesc.headerBtnDesc.btnFontStyle.flags = _kControlUseFontMask_kControlUseJustMask
colDesc.headerBtnDesc.btnContentInfo.contentType = _kControlNoContent
err = fn GetIconRef( _kOnSystemDisk, _kSystemIconsCreator, _kGenericFolderIcon, colDesc.headerBtnDesc.btnContentInfo.iconRef )

// Add the checkbox column
colDesc.propertyDesc.propertyID    = _checkboxColumnID
colDesc.propertyDesc.propertyType  = _kDataBrowserCheckboxType
colDesc.propertyDesc.propertyFlags = _kDataBrowserPropertyIsMutable _kDataBrowserDefaultPropertyFlags
colDesc.headerBtnDesc.minimumWidth = 30
colDesc.headerBtnDesc.maximumWidth = 30
colDesc.headerBtnDesc.btnFontStyle.just  = _teCenter
colDesc.headerBtnDesc.btnFontStyle.font  = _kControlFontViewSystemFont
colDesc.headerBtnDesc.btnFontStyle.style = _normal
colDesc.headerBtnDesc.titleString = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, cr, _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn )

// Add the Flavor column
colDesc.propertyDesc.propertyID    = _flavorColumnID
colDesc.propertyDesc.propertyType  = _kDataBrowserIconAndTextType
colDesc.propertyDesc.propertyFlags = _kDataBrowserPropertyIsMutable_kDataBrowserListViewSelectionColumn_kDataBrowserListViewDefaultColumnFlags
colDesc.headerBtnDesc.btnContentInfo.contentType = _kControlContentIconRef
colDesc.headerBtnDesc.minimumWidth      = 0
colDesc.headerBtnDesc.maximumWidth      = 280
colDesc.headerBtnDesc.btnFontStyle.just = _teFlushDefault
colDesc.headerBtnDesc.titleString = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault(), "Flavor", _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn )

// Add the icon column
colDesc.propertyDesc.propertyID    = _iconOnlyColumnID
colDesc.propertyDesc.propertyType  = _kDataBrowserIconType
colDesc.propertyDesc.propertyFlags = _kDataBrowserListViewSelectionColumn_kDataBrowserListViewDefaultColumnFlags
colDesc.headerBtnDesc.btnContentInfo.contentType = _kControlContentIconRef
colDesc.headerBtnDesc.minimumWidth      = 0
colDesc.headerBtnDesc.maximumWidth      = 100
colDesc.headerBtnDesc.btnFontStyle.just = _teCenter
colDesc.headerBtnDesc.titleString       = _nil
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn )

// Add the Index column
colDesc.headerBtnDesc.maximumWidth      = 120
colDesc.propertyDesc.propertyID         = _indexColumnID
colDesc.propertyDesc.propertyType       = _kDataBrowserTextType
colDesc.headerBtnDesc.btnFontStyle.just = _teCenter
colDesc.headerBtnDesc.titleString       = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, "Index", _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn)

// Add the Color column
colDesc.propertyDesc.propertyID         = _colorColumnID
colDesc.headerBtnDesc.btnFontStyle.just = _teFlushRight
colDesc.propertyDesc.propertyFlags      = _kDataBrowserPropertyIsMutable _kDataBrowserListViewDefaultColumnFlags
colDesc.headerBtnDesc.titleString       = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault(), "Color", _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn)

// Add the ItemID column
colDesc.propertyDesc.propertyID         = _itemIDColumnID
colDesc.propertyDesc.propertyFlags      = _kDataBrowserListViewDefaultColumnFlags
colDesc.headerBtnDesc.btnFontStyle.just = _teFlushDefault
colDesc.headerBtnDesc.titleString       = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault(), "ItemID", _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn)

// Add the slider column
colDesc.propertyDesc.propertyID         = _sliderColumnID
colDesc.headerBtnDesc.btnFontStyle.just = _teCenter
colDesc.propertyDesc.propertyType       = _kDataBrowserSliderType
colDesc.propertyDesc.propertyFlags      = _kDataBrowserSliderPlainThumb _kDataBrowserPropertyIsMutable _kDataBrowserListViewDefaultColumnFlags
colDesc.headerBtnDesc.minimumWidth      = 80
colDesc.headerBtnDesc.maximumWidth      = 150
colDesc.headerBtnDesc.btnContentInfo.contentType = _kControlContentTextOnly
colDesc.headerBtnDesc.titleString = fn CFStringCreateWithPascalString(fn CFAllocatorGetDefault, "Slider", _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn )

// Add the progress bar column
colDesc.propertyDesc.propertyID         = _progressColumnID
colDesc.headerBtnDesc.btnFontStyle.just = _teFlushDefault
colDesc.propertyDesc.propertyType       = _kDataBrowserRelevanceRankType
colDesc.propertyDesc.propertyFlags      = _kDataBrowserListViewDefaultColumnFlags
colDesc.headerBtnDesc.btnContentInfo.contentType = _kControlContentTextOnly
colDesc.headerBtnDesc.titleString       = fn CFStringCreateWithPascalString(fn CFAllocatorGetDefault, "Relevance Rank", _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn )

// Add date/time column
colDesc.propertyDesc.propertyID         = _dateTimeColumnID
colDesc.headerBtnDesc.btnFontStyle.just = _teFlushLeft
colDesc.propertyDesc.propertyType       = _kDataBrowserDateTimeType
colDesc.propertyDesc.propertyFlags      = _kDataBrowserListViewSelectionColumn_kDataBrowserListViewDefaultColumnFlags
colDesc.headerBtnDesc.minimumWidth      = 50
colDesc.headerBtnDesc.maximumWidth      = 200
colDesc.headerBtnDesc.titleString       = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, "Date/Time", _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn )

// Add column 8
colDesc.propertyDesc.propertyID    = _popupMenuColumnID
colDesc.propertyDesc.propertyType  = _kDataBrowserPopupMenuType
colDesc.propertyDesc.propertyFlags = _kDataBrowserPropertyIsMutable_kDataBrowserListViewDefaultColumnFlags
colDesc.headerBtnDesc.titleString  = fn CFStringCreateWithPascalString( fn CFAllocatorGetDefault, "Popup menu", _kCFStringEncodingMacRoman )
err = fn AddDataBrowserListViewColumn( browser, colDesc, _kDataBrowserListViewAppendColumn )

// Finish formatting the table
/*
err = fn SetDataBrowserTableViewRowHeight( browser, 11 )
err = fn SetDataBrowserSortProperty( browser, _flavorColumnID )
*/
err = fn SetDataBrowserListViewDisclosureColumn( browser, _flavorColumnID, _false )
err = fn ReleaseIconRef( colDesc.headerBtnDesc.btnContentInfo.iconRef )

case _kDataBrowserColumnView:
/*
dim as DataBrowserItemID path(1)
path(0) = 48 : path(1) = 485
err = fn SetDataBrowserColumnViewPath(browser, 2, @path(0))
err = fn SetDataBrowserTarget(browser, 50695)
*/
end select

// fn RestoreUserState
end fn

'~';
/*
     This function creates the DataBrowser
*/
clear local fn CreateDataBrowser( w as WindowRef )

dim as Rect         r
dim as ControlRef @ browser
dim as Boolean    @ frameAndFocus

// Create a DataBrowser
r.top   =   0 : r.left   =   0
r.right = 400 : r.bottom = 200
long if fn CreateDataBrowserControl( w, r, _kDataBrowserListView, browser ) = _noErr
// Turn off DB's focus frame
long if fn SetControlData( browser, _kControlNoPart, _kControlDataBrowserIncludesFrameAndFocusTag, sizeof(frameAndFocus), frameAndFocus )
end if
end if

end fn = browser

'~';
/*
     This function sets all the callback procedures that the
     DataBrowser will use to communicate with the program.
*/
clear local fn InstallDataBrowserCallbacks( browser as ControlRef )

dim as OSStatus               err
dim as DataBrowserCallbacks @ myCallbacks

//Use latest layout and callback signatures
myCallbacks.version = _kDataBrowserLatestCallbacks
err = fn InitDataBrowserCallbacks( myCallbacks )

myCallbacks.u.v1.itemDataCallback             = fn NewDataBrowserItemDataUPP            ([proc "GetSetItemDataProc"       + _FBprocToProcPtrOffset])
myCallbacks.u.v1.itemCompareCallback          = fn NewDataBrowserItemCompareUPP         ([proc "ItemComparisonProc"       + _FBprocToProcPtrOffset])
myCallbacks.u.v1.itemNotificationCallback     = fn NewDataBrowserItemNotificationUPP    ([proc "ItemNotificationProc"     + _FBprocToProcPtrOffset])
myCallbacks.u.v1.acceptDragCallback           = fn NewDataBrowserAcceptDragUPP          ([proc "AcceptDragProc"           + _FBprocToProcPtrOffset])
myCallbacks.u.v1.receiveDragCallback          = fn NewDataBrowserReceiveDragUPP         ([proc "ReceiveDragProc"          + _FBprocToProcPtrOffset])
myCallbacks.u.v1.addDragItemCallback          = fn NewDataBrowserAddDragItemUPP         ([proc "AddDragItemProc"          + _FBprocToProcPtrOffset])
myCallbacks.u.v1.itemHelpContentCallback      = fn NewDataBrowserItemHelpContentUPP     ([proc "ItemHelpContentProc"      + _FBprocToProcPtrOffset])
myCallbacks.u.v1.getContextualMenuCallback    = fn NewDataBrowserGetContextualMenuUPP   ([proc "GetContextualMenuProc"    + _FBprocToProcPtrOffset])
myCallbacks.u.v1.selectContextualMenuCallback = fn NewDataBrowserSelectContextualMenuUPP([proc "SelectContextualMenuProc" + _FBprocToProcPtrOffset])

err =  fn SetDataBrowserCallbacks( browser, myCallbacks )

end fn

'~----
'~Menu Handling
'~';
/*
     This function update the state of a few menu items. Depending
     on certain conditions it enables/disables and checks/unchecks
     the relevant menu items.
*/
clear local fn UpdateDataBrowserCommand( browser as ControlRef, cmd as .HICommand )

dim as OSStatus               result, err
dim as DataBrowserViewStyle @ viewStyle
dim as Boolean                commandIsEnabled

commandIsEnabled = _true

select cmd.commandID

case _showPlacardCmd:

CheckMenuItem( cmd.menu.menuRef, cmd.menu.menuItemIndex, gPlacard != _nil )

case _kHICommandCut, _kHICommandUndo, _kHICommandRedo, _kHICommandCopy, _kHICommandPaste, _kHICommandClear, _kHICommandSelectAll:

commandIsEnabled = fn EnableDataBrowserEditCommand( browser, cmd.commandID )

case _customizeViewCmd:

err = fn GetDataBrowserViewStyle( browser, viewStyle )
commandIsEnabled = ( viewStyle == _kDataBrowserListView )

CheckMenuItem( cmd.menu.menuRef, 1, ( commandIsEnabled ) )
CheckMenuItem( cmd.menu.menuRef, 3, not( commandIsEnabled ) )

case else : result = _eventNotHandledErr

end select

long if result == _noErr
long if commandIsEnabled
EnableMenuCommand( cmd.menu.menuRef, cmd.commandID )
xelse
DisableMenuCommand( cmd.menu.menuRef, cmd.commandID )
end if
end if

end fn = result

'~';
/*
     This function is similar to a menu handler, it deals
     with the end user choice in the menubar.
*/
clear local fn HandleDataBrowserCommand( inBrowser as ControlRef, cmd as .HICommand )

dim as OSStatus               result, err
dim as Rect                   sBarInset, placardBounds
dim as ControlRef           @ browser
dim as DataBrowserViewStyle @ view
dim as proc                 @ drawProc

browser = inBrowser// for RAM variable

select cmd.commandID

case _showPlacardCmd:

err = fn GetDataBrowserScrollBarInset( browser, sBarInset )

long if gPlacard
GetControlBounds( gPlacard, placardBounds )
DisposeControl( gPlacard ) : gPlacard = _nil
sBarInset.left -= placardBounds.right - placardBounds.left
xelse
GetControlBounds( browser, placardBounds )
placardBounds.top   = placardBounds.bottom - 15
placardBounds.right = placardBounds.left + 100

err = fn CreateUserPaneControl( fn GetControlOwner( browser ), placardBounds, 0, gPlacard )
long if gPlacard
err = fn SetControlVisibility( gPlacard, _true, _true )
SetControlReference( gPlacard, browser )
err = fn EmbedControl( gPlacard, browser )
sBarInset.left += placardBounds.right - placardBounds.left

drawProc = fn NewControlUserPaneDrawUPP( [proc "PlacardDrawProc" + _FBprocToProcPtrOffset] )
if fn SetControlData( gPlacard, _kControlNoPart, _kControlUserPaneDrawProcTag, sizeof(drawProc), drawProc ) then exit case
DrawOneControl( gPlacard )
end if
end if
err = fn SetDataBrowserScrollBarInset( browser, sBarInset )

// Rem'd out in the original Apple example file
case _kHICommandCut, _kHICommandUndo, _kHICommandRedo, _kHICommandCopy, _kHICommandPaste, _kHICommandClear, _kHICommandSelectAll:

err = fn ExecuteDataBrowserEditCommand( browser, cmd.commandID )

case _kDataBrowserListView, _kDataBrowserColumnView:

err = fn GetDataBrowserViewStyle( browser, view )

long if ( view != cmd.commandID )
err = fn SetDataBrowserViewStyle( browser, cmd.commandID )
fn ConfigureDataBrowser( browser )
end if

case _DataBrowserSettingsCmd   : fn SetupCustomizer( browser, _settingsDLOGResID )

case _customizeViewCmd         : fn SetupCustomizer( browser, _customizeDLOGResID )

case else                      : result = _eventNotHandledErr

end select

end fn = result

'~';
/*
     This function simply gets and draw the menubar in resource
*/
clear local fn InstallStandardMenuBar( draw as Boolean )

dim as Handle menuBar

menuBar = fn GetNewMBar( 128 )
if menuBar then SetMenuBar( menuBar )
if draw    then DrawMenuBar

end fn = _noErr


'~';
'~Event Handling
/*
     This function will process the events the window can handle
*/
clear local fn HandleWindowCommand( inEvent as EventRef )

dim as ControlRef    browser
dim as HICommand     cmd
dim as OSStatus      result,err
dim as WindowRef   @ w
dim as EventRef    @ evt

result = _eventNotHandledErr
err    = fn GetEventParameter( inEvent, _kEventParamDirectObject, _typeHICommand, #_nil, sizeof(cmd), #_nil, @cmd )
w      = fn GetUserFocusWindow

browser = fn GetDataBrowserFromWindow( w )

select fn GetEventKind( inEvent )

case _kEventCommandProcess:

long if ( cmd.commandID == _closeWindowCmd )
dim as EventTime   eT// Robert Purves' fix ( 8/05/03 }
eT     = fn GetCurrentEventTime
result = _noErr
err    = fn CreateEvent( _nil, _kEventClassWindow, _kEventWindowClose, eT, _kEventAttributeUserEvent, @evt )
err    = fn SetEventParameter( evt, _kEventParamDirectObject, _typeWindowRef, sizeof(w), w )
if err == _noErr then fn SendEventToWindow( evt, fn GetUserFocusWindow )
xelse
result = fn HandleDataBrowserCommand( browser, cmd )
end if

case _kEventCommandUpdateStatus:

result = fn UpdateDataBrowserCommand( browser, cmd )

end select

end fn = result

'~'1
/*
     This function will handle the events targetted at our
     two dialog windows for customization.
*/
clear local fn MyDialogEventHandler( EventHandlerCallRef as ptr, inEvent as EventRef, void as ptr )

dim as OSStatus     result, err
dim as UInt16       customizerID
dim as ControlRef   browser, @ c
dim as DialogRef  @ dlog
dim as WindowRef  @ w
dim as proc       @ eventHandler

result = _eventNotHandledErr

select fn GetEventClass( inEvent )

case _kEventClassCommand:

result = fn HandleWindowCommand( inEvent )

case _kEventClassControl:

result = _noErr
err = fn GetEventParameter( inEvent, _kEventParamDirectObject, _typeControlRef, #_nil, sizeof(c), #_nil, c )
fn HandleCustomizerControl( c )

case _kEventClassWindow:

err  = fn GetEventParameter( inEvent, _kEventParamDirectObject, _typeWindowRef, #_nil, sizeof(w), #_nil, w )
dlog = fn GetDialogFromWindow( w )

select fn GetEventKind( inEvent )

case _kEventWindowClose:

result       = _noErr
browser      = fn GetDataBrowserFromWindow( w )
customizerID = fn GetCustomerID( w )
err = fn GetWindowProperty( w, _myCreator, _myEventHandler, sizeof(eventHandler), #_nil, eventHandler )
if eventHandler then DisposeEventHandlerUPP( eventHandler )
DisposeDialog( dlog ) : dlog = _nil

err = fn SetControlProperty( browser, _myCreator, customizerID, sizeof(dlog), dlog )
end select

end select

end fn = result

'~'1
/*
     This function is called by a callback procedure installed
     with the main window. It is a bit similar to a traditional
     dialog event handler except that it is specific to this window.
*/
clear local fn MyWindowEventHandler( EventHandlerCallRef as ptr, inEvent as EventRef, void as ptr )

dim as OSStatus    result, err
dim as ControlRef  browser
dim as DialogRef   customizer
dim as UInt16      IDs(1)
dim as UInt16      i, @ ID
dim as WindowRef @ w
dim as Rect        r

result = _noErr

select fn GetEventClass( inEvent )

case _kEventClassCommand:

result = fn HandleWindowCommand( inEvent )

case _kEventClassWindow:

err = fn GetEventParameter( inEvent, _kEventParamDirectObject, _typeWindowRef, #_nil, sizeof(w), #_nil, w )

select fn GetEventKind( inEvent )

case _kEventWindowClose:

browser = fn GetDataBrowserFromWindow( w )
IDs(0)  = _settingsDLOGResID
IDs(1)  = _customizeDLOGResID

for i = 0 to 1
ID = IDs(i)
customizer = fn GetCustomizer( browser, ID )
if customizer then DisposeDialog( customizer )
next

DisposeWindow( w )
QuitApplicationEventLoop

case _kEventWindowBoundsChanged:

browser = fn GetDataBrowserFromWindow( w )

err = fn GetPortBounds( fn GetWindowPort( w ), r )
// err = fn GetWindowBounds( w, _kWindowContentRgn, r )
SizeControl( browser, r.right - r.left, r.bottom - r.top )

#if def _typeQDPoint

case _kEventWindowGetIdealSize:

dim as Rect     bestRect
dim as SInt16 @ baseLine
dim as Point  @ idealDimensions

err = fn GetBestControlRect( fn GetDataBrowserFromWindow( w ), bestRect, baseLine )
err = fn SetEventParameter( inEvent, _kEventParamDimensions, _typeQDPoint, sizeof(idealDimensions), idealDimensions )

case _kEventWindowGetClickActivation:

dim as Point                 @ mousePt
dim as UInt32                @ modifiers
dim as ClickActivationResult @ activation

err = fn GetEventParameter( inEvent, _kEventParamMouseLocation, _typeQDPoint, #_nil, sizeof(mousePt)  , #_nil, mousePt )
err = fn GetEventParameter( inEvent, _kEventParamKeyModifiers , _typeUInt32 , #_nil, sizeof(modifiers), #_nil, modifiers )
err = fn GetControlClickActivation( fn GetDataBrowserFromWindow( w ), mousePt, modifiers, activation )
err = fn SetEventParameter( inEvent, _kEventParamClickActivation, _typeClickActivationResult, sizeof(activation), activation )

#endif // defined(typeQDPoint)

case _kEventWindowContextualMenuSelect:

case else

result = _eventNotHandledErr

end select

case else
result = _eventNotHandledErr

end select

end fn = result


'~';
'~Program Setup
/*
     This function is called at startup to setup a few globals.

*/
clear local fn SetupGlobals

dim as IconRef  @ aliasBadgeIcon
dim as OSStatus   err

// getting our menu from resource
gContextualMenu = fn GetMenu( _contextualMenuResID ) : InsertMenu( gContextualMenu, -1 )

// getting three icons that are stored in an array
err = fn GetIconRef( _kOnSystemDisk, _kSystemIconsCreator, _kGenericFolderIcon  , gIcon(_folderIndex) )
err = fn GetIconRef( _kOnSystemDisk, _kSystemIconsCreator, _kGenericDocumentIcon, gIcon(_documentIndex) )
err = fn GetIconRef( _kOnSystemDisk, _kSystemIconsCreator, _kAliasBadgeIcon     , aliasBadgeIcon )

err = fn CompositeIconRef( gIcon(_folderIndex), aliasBadgeIcon, gIcon(_folderAliasIndex) )
if aliasBadgeIcon then err = fn ReleaseIconRef( aliasBadgeIcon )

// setting unique values for the DataBrowser columns
gCols(0)  = _checkboxColumnID
gCols(1)  = _flavorColumnID
gCols(2)  = _iconOnlyColumnID
gCols(3)  = _indexColumnID
gCols(4)  = _colorColumnID
gCols(5)  = _itemIDColumnID
gCols(6)  = _sliderColumnID
gCols(7)  = _progressColumnID
gCols(8)  = _dateTimeColumnID
gCols(9)  = _popupMenuColumnID

end fn

'~';
/*
     Cleaning up memory when the application ends.
*/
local fn CleanupGlobals

dim as UInt32   i
dim as OSStatus err

long if gContextualMenu
DeleteMenu( _contextualMenuResID )
DisposeMenu( gContextualMenu )
end if

for i = 0 to _totalNumIcons - 1
if gIcon(i) then err = fn ReleaseIconRef( gIcon(i) )
next

end fn

'~';
/*
     The callback routines are redirected to local functions.
     In fact, the functions called are prototypes. The function
     below sets the vectors for all the prototype functions.
*/
clear local fn SetupMyVectors

gDialogEventHandlerProc   = @fn MyDialogEventHandler
gWindowEventHandlerProc   = @fn MyWindowEventHandler

gPlacardDrawProc          = @fn MyPlacardDraw

gAcceptDragProc           = @fn MyAcceptDrag
gReceiveDragProc          = @fn MyReceiveDrag
gAddDragItemProc          = @fn MyAddDragItem
gGetSetItemDataProc       = @fn MyGetSetItemData
gItemComparisonProc       = @fn MyItemComparison
gItemNotificationProc     = @fn MyItemNotification
gItemHelpContentProc      = @fn MyItemHelpContent
gGetContextualMenuProc    = @fn MyGetContextualMenu
gSelectContextualMenuProc = @fn MySelectContextualMenu

end fn

'~Main Program
/*
     The main is just a function without event loop since the
     program uses Carbon Events.
     It creates a window and a DataBrowser, configure it and
     show the result on screen.
*/
clear local fn main

dim as OSStatus        err
dim as Rect            r
dim as WindowRef     @ w
dim as ControlRef    @ browser, rootControl
dim as EventTypeSpec   wEvnt(6)

SetRect( r, 200, 200, 600, 400 )

// the events accepted by the main window
wEvnt.eventClass(0) = _kEventClassCommand
wEvnt.eventKind (0) = _kEventCommandProcess

wEvnt.eventClass(1) = _kEventClassCommand
wEvnt.eventKind (1) = _kEventCommandUpdateStatus

wEvnt.eventClass(2) = _kEventClassWindow
wEvnt.eventKind (2) = _kEventWindowClose

wEvnt.eventClass(3) = _kEventClassWindow
wEvnt.eventKind (3) = _kEventWindowGetIdealSize

wEvnt.eventClass(4) = _kEventClassWindow
wEvnt.eventKind (4) = _kEventWindowBoundsChanged

wEvnt.eventClass(5) = _kEventClassWindow
wEvnt.eventKind (5) = _kEventWindowGetClickActivation

wEvnt.eventClass(6) = _kEventClassWindow
wEvnt.eventKind (6) = _kEventWindowContextualMenuSelect


// Setup a few global variables
fn SetupGlobals
// Setup global vectors for the callback routines
fn SetupMyVectors
// Setup menubar
err = fn InstallStandardMenuBar( _true )
// Setup a window
long if fn CreateNewWindow(                                                    _kDocumentWindowClass, ┬
_kWindowInWindowMenuAttribute _kWindowStandardHandlerAttribute _kWindowStandardDocumentAttributes, ┬
                                                                                                r, ┬
                                                                                                w )
exit fn
end if

err = fn CreateRootControl( w, rootControl )
err = fn SetAutomaticControlDragTrackingEnabledForWindow( w, _true )

long if fn InstallWindowEventHandler(                                              w, ┬
fn NewEventHandlerUPP( [proc "WindowEventHandlerProc" + _FBprocToProcPtrOffset] ), ┬
                                                                                7, ┬
                                                                        @wEvnt(0), ┬
                                                                            #_nil, ┬
                                                                            #_nil )
exit fn
end if
err = fn SetWindowTitleWithCFString( w, fn CFSTR("DataBrowser Demo") )

// Create the DataBrowser and install the callback routines
browser = fn CreateDataBrowser( w )
fn InstallDataBrowserCallbacks( browser )

// Configure the DataBrowser
fn ConfigureDataBrowser( browser )
err = fn SetDataBrowserTarget( browser, 50 )

// Set the keyboard focus
err = fn SetKeyboardFocus( w, browser, _kControlDataBrowserPart )

// Store our custom DataBrowser ID as a window property
err = fn SetWindowProperty( w, _myCreator, _myDataBrowser, sizeof(browser), browser )

// Show window & run
ShowWindow( w )
RunApplicationEventLoop
fn CleanupGlobals

end fn = err

'~';
// the program starts here calling the main function
fn Main

end

'~---
'~Applications Procs
/*
     Entry points for the callback procedures
*/
#if def _FBUseDebugger
troff
#endif

goto "skip procs"

'~';

"AcceptDragProc"
enterproc fn AcceptDragProc( browser as ControlRef, theDrag as DragReference, itemID as DataBrowserItemID ) = Boolean
exitproc = fn Proto_AcceptDrag( browser, theDrag, itemID )

'~';

"ReceiveDragProc"
enterproc fn ReceiveDragProc( browser as ControlRef, theDrag as DragReference, itemID as DataBrowserItemID ) = boolean
exitproc = fn Proto_ReceiveDrag( browser, theDrag, itemID )

'~';

"AddDragItemProc"
enterproc fn AddDragItemProc( browser as ControlRef, theDrag as DragReference, inItemID as DataBrowserItemID, itemRef as .ItemReference ) = Boolean
exitproc = fn Proto_AddDragItem( browser , theDrag, inItemID, itemRef )

'~';

"GetSetItemDataProc"
enterproc fn GetSetItemDataProc( browser as ControlRef, itemID as DataBrowserItemID, prop as DataBrowserPropertyID, itemData as DataBrowserItemDataRef, changeValue as Boolean ) = OSStatus
exitproc = fn Proto_GetSetItemData( browser, itemID, prop, itemData, changeValue )

'~';

"ItemComparisonProc"
enterproc fn ItemComparisonProc( browser as ControlRef, itemOneID as DataBrowserItemID, itemTwoID as DataBrowserItemID, sortProperty as DataBrowserPropertyID ) = Boolean
exitproc = fn Proto_ItemComparison( browser, itemOneID, itemTwoID, sortProperty )

'~';

"ItemNotificationProc"
enterproc ItemNotificationProc( browser as ControlRef, itemID as DataBrowserItemID, message as DataBrowserItemNotification )
fn Proto_ItemNotification( browser, itemID, message )
exitproc

'~';

"ItemHelpContentProc"
enterproc ItemHelpContentProc( browser as ControlRef, item as DataBrowserItemID, prop as DataBrowserPropertyID, inRequest as HMContentRequest, outContentProvided as .HMContentProvidedType, ioHelpContent as .HMHelpContentRec )
fn Proto_ItemHelpContent( browser, item, prop, inRequest, outContentProvided, ioHelpContent )
exitproc

'~';

"GetContextualMenuProc"
enterproc GetContextualMenuProc( browser as ControlRef, @contextualMenu as .MenuRef, helpType as .UInt32, @helpItemString as .CFStringRef, selection as .AEDesc )
fn Proto_ContextualMenu( browser, contextualMenu, helpType, helpItemString, selection )
exitproc

'~';

"SelectContextualMenuProc"
enterproc SelectContextualMenuProc( browser as ControlRef, contextualMenu as MenuRef, selectionType as UInt32, menuID as SInt16, menuItem as MenuItemIndex )
fn Proto_SelectContextualMenu( browser, contextualMenu, selectionType, menuID, menuItem )
exitproc

'~';

"PlacardDrawProc"
enterproc PlacardDrawProc( c as ControlRef, dummy as SInt16 )
fn Proto_PlacardDraw( c, dummy )
exitproc

'~';

"DialogEventHandlerProc"
enterproc fn DialogEventHandlerProc( EventHandlerCallRef as ptr, inEvent as EventRef, void as ptr ) = OSStatus
exitproc = fn Proto_DialogEventHandler( EventHandlerCallRef, inEvent, void )

'~';

"WindowEventHandlerProc"
enterproc fn WindowEventHandlerProc( EventHandlerCallRef as ptr, inEvent as EventRef, void as ptr ) = OSStatus
exitproc = fn Proto_WindowEventHandler( EventHandlerCallRef, inEvent, void )


"skip procs"

#if def _FBUseDebugger
tron
#endif